﻿using System;
using System.Collections.Generic;

using System.Text;
using Rance.Tools;
using System.Reflection;

namespace Rance.Battle
{
    public class ActionEventArgs : EventArgs
    {
        public 角色Struct 角色 { get; set; }
        public bool IsSelf { get; set; }
        public List<Data技能> 技能List { get; set; }
    }

    public class ActionResultEventArgs : EventArgs
    {
        public Data队伍状态 队伍状态 { get; set; }
    }

    public class WarEndEventArgs : EventArgs
    {
        public Data战斗结果 Data战斗结果 { get; set; }
    }

    public class 战斗管理
    {
        #region 通信

        #region 服务器端发送


        //接受可以行动的指令
        public event EventHandler<ActionEventArgs> Team1ActionEvent;
        //接受行动结果的指令
        public event EventHandler<ActionResultEventArgs> Team1ActionResultEvent;
        //接受战斗结束的指令
        public event EventHandler<WarEndEventArgs> Team1WarEndEvent;

        //接受可以行动的指令
        public event EventHandler<ActionEventArgs> Team2ActionEvent;
        //接受行动结果的指令
        public event EventHandler<ActionResultEventArgs> Team2ActionResultEvent;
        //接受战斗结束的指令
        public event EventHandler<WarEndEventArgs> Team2WarEndEvent;

        #endregion

        #region 客户端发送

        public Guid Get队伍1ID()
        {
            return 战场.队伍状态1.ID;
        }

        public Guid Get队伍2ID()
        {
            return 战场.队伍状态2.ID;
        }

        public Data队伍状态 ReceiveNewlyAction(Guid 队伍ID)
        {
            队伍状况 队伍状况 = get队伍状况(队伍ID);
            if (队伍状况 == null)
                return null;

            Data队伍状态 data队伍状态 = new Data队伍状态();
            data队伍状态.ID = 队伍状况.ID;
            data队伍状态.Name = 队伍状况.队伍.Name;
            data队伍状态.对手Name = 队伍状况.对手状态.队伍.Name;
            data队伍状态.战果 = 队伍状况.战果;
            data队伍状态.战场修正 = 队伍状况.战场修正;
            data队伍状态.当前回合 = 队伍状况.战场.当前回合;
            data队伍状态.最大回合数 = 队伍状况.战场.最大回合数;

            foreach (var item in 队伍状况.队伍.成员List)
                data队伍状态.己方角色List.Add(copy角色(item));

            foreach (var item in 队伍状况.对手状态.队伍.成员List)
                data队伍状态.对手角色List.Add(copy角色(item));

            if (队伍状况.行动结果List.Count > 0)
            {
                data队伍状态.行动结果 = 队伍状况.行动结果List[队伍状况.行动结果List.Count - 1];
            }

            data队伍状态.行动顺序 = new List<Guid>();
            foreach (var 角色 in 战场.行动顺序.List)
                data队伍状态.行动顺序.Add(角色.ID);

            return data队伍状态;
        }

        private bool team1Ready;
        private bool team2Ready;

        public void Ready(Guid 队伍ID)
        { 
            if (战场.队伍状态1.ID == 队伍ID)
            {
                if (!team1Ready)
                    team1Ready = true;
                else
                    return;
            }
            else if (战场.队伍状态2.ID == 队伍ID)
            {
                if (!team2Ready)
                    team2Ready = true;
                else
                    return;
            }

            if (team1Ready && team2Ready)
                nextAction();
        }

        private void waitReady()
        {
            team1Ready = !战场.队伍状态1.IsUser;
            team2Ready = !战场.队伍状态2.IsUser;
        }

        public void Action(Guid 角色ID, string 技能, List<Guid> targetIDList)
        {
            #region 准备环境

            var 角色 = 战场.行动顺序.AllList.Find(r => r.ID == 角色ID);
                      
            if (角色 == null || 角色.是否败退 || (角色.是否完结 && !角色.是否准备))
            {
                actionError();
                return;
            }

            List<角色> targetList = new List<角色>();
            foreach (var id in targetIDList)
            {
                var target = 战场.行动顺序.AllList.Find(r => r.ID == id);
                              
                if (角色 == null)
                {
                    actionError();
                    return;
                }

                targetList.Add(target);
            }

            角色.临时攻 = 角色.攻;
            角色.临时防 = 角色.防;
            角色.临时速 = 角色.速;
            角色.临时智 = 角色.智;
            角色.本回合法术减伤 = 角色.法术减伤;
            角色.本回合物理穿透 = 角色.物理穿透;
            角色.本回合物理额外伤害 = 角色.物理额外伤害;
            角色.本回合物理减伤 = 角色.物理减伤;


            技能环境 技能环境 = createEnvironment(角色, 角色.是否队伍1, targetList, 技能);

            主动技能 主动技能 = null;
            if (技能 == "待机")
                主动技能 = 角色.待机;
            else if (技能 == 角色.基础攻击技能.Name)
                主动技能 = 角色.基础攻击技能;
            else if (角色.技能1 != null && 技能 == 角色.技能1.Name)
                主动技能 = 角色.技能1;
            else if (角色.技能2 != null && 技能 == 角色.技能2.Name)
                主动技能 = 角色.技能2;
            else if (角色.准备技能 != null && 技能 == 角色.准备技能.Name)
                主动技能 = 角色.准备技能;
            else
            {
                actionError();
                return;
            }

            #endregion

            #region 结算技能效果

            List<效果> 要删除的效果List = new List<效果>();

            foreach (var 效果 in 角色.效果List)
            {
                if (效果 is 技能效果)
                {
                    技能效果 技能效果 = 效果 as 技能效果;
                    var result = 技能效果.Excute(主动技能);
                    if (效果.持续类型 == 效果持续类型.一次 && result)
                        效果.是否执行 = true;
                }
            }

            #endregion

            #region 结算行动力消耗

            switch (主动技能.消耗行动点)
            {
                case 消耗行动点.无消耗:
                    break;
                case 消耗行动点.一点:
                    角色.行动点--;
                    break;
                case 消耗行动点.两点:
                    角色.行动点 -= 2;
                    break;
                case 消耗行动点.三点:
                    角色.行动点 -= 3;
                    break;
                case 消耗行动点.全部:
                    角色.行动点 = 0;
                    break;
            }

            if (角色.行动点 < 0)
            {
                actionError();
                return;
            }

            #endregion

            主动技能.Excute(技能环境);


            #region 结算自动恢复

            if (角色.自动恢复 > 0)
            {
                int value = 角色.最大兵力 - 角色.兵力;
                if (value > 角色.自动恢复)
                    value = 角色.自动恢复;
                if (value > 0)
                {
                    角色.兵力 += value;

                    恢复Behavior behavior = new 恢复Behavior();
                    behavior.List.Add(new 恢复BehaviorDetail() { 角色 = new 角色Struct() { ID = 角色.ID, Name = 角色.Name }, 恢复量 = value });

                    技能环境.行动结果.ResultList.Add(behavior);
                }
            }

            #endregion

            #region 清除单回合赋予

            List<string> 清除单回合赋予List = new List<string>();


            if (角色.攻击赋予 != null && 角色.攻击赋予.是否单回合)
            {
                if (角色.攻击赋予.回合数 == 1)
                {
                    角色.Clear攻击赋予();
                    清除单回合赋予List.Add("攻击");
                }
                else
                    角色.攻击赋予.回合数++;
            }

            if (角色.防御赋予 != null && 角色.防御赋予.是否单回合)
            {
                if (角色.防御赋予.回合数 == 1)
                {
                    角色.Clear防御赋予();
                    清除单回合赋予List.Add("防御");
                }
                else
                    角色.防御赋予.回合数++;
            }

            if (角色.速度赋予 != null && 角色.速度赋予.是否单回合)
            {
                if (角色.速度赋予.回合数 == 1)
                {
                    角色.Clear速度赋予();
                    清除单回合赋予List.Add("速度");
                }
                else
                    角色.速度赋予.回合数++;
            }

            if (角色.智力赋予 != null && 角色.智力赋予.是否单回合)
            {
                if (角色.智力赋予.回合数 == 1)
                {
                    角色.Clear智力赋予();
                    清除单回合赋予List.Add("智力");
                }
                else
                    角色.智力赋予.回合数++;
            }

            if (清除单回合赋予List.Count > 0)
            {
                赋予解除Behavior behavior = new 赋予解除Behavior();
                behavior.List.Add(new 赋予解除BehaviorDetail() { 角色 = new 角色Struct() { ID = 角色.ID, Name = 角色.Name }, List = 清除单回合赋予List });
                技能环境.行动结果.ResultList.Add(behavior);
            }

            #endregion

            #region 清除效果

            foreach (var 效果 in 角色.效果List.ToArray())
            {
                if (效果.持续类型 == 效果持续类型.一回合)
                {
                    if (效果.回合数 == 0)
                        效果.回合数++;
                    else if (效果.回合数 == 1)
                        角色.效果List.Remove(效果);
                }
                else if (效果.持续类型 == 效果持续类型.一次)
                {
                    if (效果.是否执行)
                    {
                        if (效果 is 技能效果)
                        {
                            技能效果 技能效果 = (技能效果)效果;
                            技能效果.Restore();
                        }
                        角色.效果List.Remove(效果);
                    }
                }
            }

            #endregion

            #region 结算回合结束被动技能

            if (角色.被动技能 is 自己回合结束被动技能)
            {
                自己回合结束被动技能 自己回合结束被动技能 = (自己回合结束被动技能)角色.被动技能;
                自己回合结束被动技能.Excute(技能环境, 角色);
            }

            foreach (var item in 战场.队伍状态1.队伍.成员List)
            {
                if (!item.是否败退)
                {
                    if (item.被动技能 is 回合结束被动技能)
                    {
                        回合结束被动技能 回合结束被动技能 = (回合结束被动技能)item.被动技能;
                        回合结束被动技能.Excute(技能环境, item);
                    }
                }
            }

            foreach (var item in 战场.队伍状态2.队伍.成员List)
            {
                if (!item.是否败退)
                {
                    if (item.被动技能 is 回合结束被动技能)
                    {
                        回合结束被动技能 回合结束被动技能 = (回合结束被动技能)item.被动技能;
                        回合结束被动技能.Excute(技能环境, item);
                    }
                    break;
                }
            }

            #endregion

            #region 结算回合

            战场.当前回合++;
            if (战场.当前回合 > 战场.最大回合数)
                战场.当前回合 = 战场.最大回合数;

            bool allDie = true;
            bool allEnd = true;
            bool isEnd = false;
            foreach (var item in 战场.队伍状态1.队伍.成员List)
            {
                if (!item.是否完结 || item.是否准备)
                    allEnd = false;
                if (!item.是否败退)
                    allDie = false;
            }

            if (allDie)
                isEnd = true;
            else
            {
                allDie = true;
                foreach (var item in 战场.队伍状态2.队伍.成员List)
                {
                    if (!item.是否完结 || item.是否准备)
                        allEnd = false;
                    if (!item.是否败退)
                        allDie = false;
                }

                if (allDie || allEnd)
                    isEnd = true;
            }

            #endregion

            //行动完毕之后执行
            技能环境.End();

            waitReady();

            #region 发送行动通知

            if (战场.队伍状态1.IsUser)
            {
                if (Team1ActionResultEvent != null)
                {
                    ActionResultEventArgs args = new ActionResultEventArgs() { 队伍状态 = ReceiveNewlyAction(战场.队伍状态1.ID) };
                    Team1ActionResultEvent(null, args);
                }
            }

            if (战场.队伍状态2.IsUser)
            {
                if (Team2ActionResultEvent != null)
                {
                    ActionResultEventArgs args = new ActionResultEventArgs() { 队伍状态 = ReceiveNewlyAction(战场.队伍状态2.ID) };
                    Team2ActionResultEvent(null, args);
                }
            }

            #endregion

            //nextAction();
        }

        //public void Start(Guid 队伍ID)
        //{
        //    if (战场.队伍状态1.ID == 队伍ID)
        //        战场.队伍状态1.IsStart = true;
        //    else if (战场.队伍状态2.ID == 队伍ID)
        //        战场.队伍状态2.IsStart = true;

        //    if (战场.队伍状态1.IsStart && 战场.队伍状态2.IsStart)
        //        nextAction();
        // }

        public static List<string> GetSelectList(string 技能)
        {
            switch (技能)
            {
                case "王者之阵":
                    return new List<string>() { "攻击", "防御", "速度", "智力" };
                case "神机妙算":
                    return new List<string>() { "增加4回合", "减少4回合", "不变" };
                default:
                    return null;
            }
        }

        #endregion

        #endregion

        #region New

        private 战场 战场;


        private Data战斗角色 copy角色(角色 角色)
        {
            Data战斗角色 战斗角色 = new Data战斗角色();
            战斗角色.ID = 角色.ID;
            战斗角色.Name = 角色.Name;
            战斗角色.兵种 = 角色.兵种.Name;
            战斗角色.攻 = 角色.攻;
            战斗角色.防 = 角色.防;
            战斗角色.智 = 角色.智;
            战斗角色.速 = 角色.速;
            战斗角色.行动点 = 角色.行动点;
            战斗角色.最大行动点 = 角色.最大行动点;
            战斗角色.兵力 = 角色.兵力;
            战斗角色.最大兵力 = 角色.最大兵力;
            战斗角色.排 = 角色.排;
            战斗角色.列 = 角色.列;
            战斗角色.顺序值 = 角色.顺序值;

            if (角色.攻击赋予 != null)
                战斗角色.攻状态 = 属性状态.赋予;
            else if (角色.攻击诅咒 != null)
                战斗角色.攻状态 = 属性状态.诅咒;
            else
                战斗角色.攻状态 = 属性状态.无;

            if (角色.防御赋予 != null)
                战斗角色.防状态 = 属性状态.赋予;
            else if (角色.防御诅咒 != null)
                战斗角色.防状态 = 属性状态.诅咒;
            else
                战斗角色.防状态 = 属性状态.无;

            if (角色.速度赋予 != null)
                战斗角色.速状态 = 属性状态.赋予;
            else if (角色.速度诅咒 != null)
                战斗角色.速状态 = 属性状态.诅咒;
            else
                战斗角色.速状态 = 属性状态.无;

            if (角色.智力赋予 != null)
                战斗角色.智状态 = 属性状态.赋予;
            else if (角色.智力诅咒 != null)
                战斗角色.智状态 = 属性状态.诅咒;
            else
                战斗角色.智状态 = 属性状态.无;

            战斗角色.守护率 = 角色.守护率;
            战斗角色.全体守护率 = 角色.全体守护率;
            战斗角色.护盾 = 角色.护盾;

            战斗角色.是否败退 = 角色.是否败退;
            战斗角色.是否准备 = 角色.是否准备;

            return 战斗角色;
        }




        private 队伍状况 get队伍状况(Guid 队伍ID)
        {
            队伍状况 队伍状况 = null;
            if (战场.队伍状态1.ID == 队伍ID)
                队伍状况 = 战场.队伍状态1;
            else if (战场.队伍状态2.ID == 队伍ID)
                队伍状况 = 战场.队伍状态2;

            return 队伍状况;
        }



        public 战斗管理(Data战斗 战斗)
        {
            //初始化队伍
            战场 = new 战场();
            战场.队伍状态1.队伍.Name = 战斗.队伍1.Name;
            战场.队伍状态1.IsUser = 战斗.队伍1.IsUser;
            战场.队伍状态1.IsControlByComputer = !战场.队伍状态1.IsUser;
            foreach (var item in 战斗.队伍1.List)
            {
                角色 角色 = Create(item.Name, item.兵种, item.攻, item.防, item.智, item.速, item.最大行动点, item.兵力, item.最大兵力, item.排, item.列, item.技能1, item.技能2, item.技能3, item.技能4, item.隐藏技能, item.战斗开始被动技能选择, item.特殊人物, item.装备, item.AI);
                角色.是否队伍1 = true;
                战场.队伍状态1.队伍.成员List.Add(角色);
            }

            战场.队伍状态2.队伍.Name = 战斗.队伍2.Name;
            战场.队伍状态2.IsUser = 战斗.队伍2.IsUser;
            战场.队伍状态2.IsControlByComputer = !战场.队伍状态2.IsUser;
            foreach (var item in 战斗.队伍2.List)
            {
                角色 角色 = Create(item.Name, item.兵种, item.攻, item.防, item.智, item.速, item.最大行动点, item.兵力, item.最大兵力, item.排, item.列, item.技能1, item.技能2, item.技能3, item.技能4, item.隐藏技能, item.战斗开始被动技能选择, item.特殊人物, item.装备, item.AI);
                角色.是否队伍1 = false;
                战场.队伍状态2.队伍.成员List.Add(角色);
            }

            //初始化战场
            switch (战斗.战地类型)
            {
                case Battle.战地类型.野战:
                    战场.队伍状态1.战场修正 = 0;
                    战场.队伍状态1.战果 = 0;
                    break;
                case Battle.战地类型.防守_城市:
                    战场.队伍状态1.战场修正 = 20;
                    战场.队伍状态1.战果 = 500;
                    break;
                case Battle.战地类型.防守_小镇:
                    战场.队伍状态1.战场修正 = 12;
                    战场.队伍状态1.战果 = 200;
                    break;
                case Battle.战地类型.防守_山寨:
                    战场.队伍状态1.战场修正 = 4;
                    战场.队伍状态1.战果 = 0;
                    break;
                case Battle.战地类型.进攻_城市:
                    战场.队伍状态1.战场修正 = -20;
                    战场.队伍状态1.战果 = -500;
                    break;
                case Battle.战地类型.进攻_小镇:
                    战场.队伍状态1.战场修正 = -12;
                    战场.队伍状态1.战果 = -200;
                    break;
                case Battle.战地类型.进攻_山寨:
                    战场.队伍状态1.战场修正 = -4;
                    战场.队伍状态1.战果 = 0;
                    break;
            }
            战场.队伍状态2.战场修正 = 0 - 战场.队伍状态1.战场修正;
            战场.队伍状态2.战果 = 0 - 战场.队伍状态1.战果;

            //战斗开始被动技能
            List<string> 唯一被动List = new List<string>();
            foreach (var 角色 in 战场.队伍状态1.队伍.成员List)
            {
                if (角色.被动技能 != null && 角色.被动技能 is 战斗开始被动技能)
                {
                    if (角色.被动技能.是否唯一)
                    {
                        if (唯一被动List.Contains(角色.被动技能.Name))
                            continue;

                        唯一被动List.Add(角色.被动技能.Name);
                    }

                    战斗开始被动技能 战斗开始被动技能 = (战斗开始被动技能)角色.被动技能;
                    技能环境 技能环境 = createEnvironment(角色, true, new List<角色>() { 角色 }, 角色.被动技能.Name);
                    战斗开始被动技能.Excute(技能环境);
                }

                if (角色.被动技能 != null && 角色.被动技能 is 战斗开始选择被动技能)
                {
                    if (角色.被动技能.是否唯一)
                    {
                        if (唯一被动List.Contains(角色.被动技能.Name))
                            continue;

                        唯一被动List.Add(角色.被动技能.Name);
                    }

                    战斗开始选择被动技能 战斗开始选择被动技能 = (战斗开始选择被动技能)角色.被动技能;
                    技能环境 技能环境 = createEnvironment(角色, true, new List<角色>() { 角色 }, 角色.被动技能.Name);
                    战斗开始选择被动技能.Excute(技能环境, 角色.战斗开始被动技能选择);
                }

                if (角色.隐藏技能 != null && 角色.隐藏技能 is 战斗开始被动技能)
                {
                    战斗开始被动技能 战斗开始被动技能 = (战斗开始被动技能)角色.隐藏技能;

                    if (战斗开始被动技能.是否唯一)
                    {
                        if (唯一被动List.Contains(战斗开始被动技能.Name))
                            continue;

                        唯一被动List.Add(战斗开始被动技能.Name);
                    }

                    技能环境 技能环境 = createEnvironment(角色, true, new List<角色>() { 角色 }, 角色.隐藏技能.Name);
                    战斗开始被动技能.Excute(技能环境);
                }
            }

            唯一被动List.Clear();
            foreach (var 角色 in 战场.队伍状态2.队伍.成员List)
            {
                if (角色.被动技能 != null && 角色.被动技能 is 战斗开始被动技能)
                {
                    if (角色.被动技能.是否唯一)
                    {
                        if (唯一被动List.Contains(角色.被动技能.Name))
                            continue;

                        唯一被动List.Add(角色.被动技能.Name);
                    }

                    战斗开始被动技能 战斗开始被动技能 = (战斗开始被动技能)角色.被动技能;
                    技能环境 技能环境 = createEnvironment(角色, true, new List<角色>() { 角色 }, 角色.被动技能.Name);
                    战斗开始被动技能.Excute(技能环境);
                }

                if (角色.被动技能 != null && 角色.被动技能 is 战斗开始选择被动技能)
                {
                    if (角色.被动技能.是否唯一)
                    {
                        if (唯一被动List.Contains(角色.被动技能.Name))
                            continue;

                        唯一被动List.Add(角色.被动技能.Name);
                    }

                    战斗开始选择被动技能 战斗开始选择被动技能 = (战斗开始选择被动技能)角色.被动技能;
                    技能环境 技能环境 = createEnvironment(角色, true, new List<角色>() { 角色 }, 角色.被动技能.Name);
                    战斗开始选择被动技能.Excute(技能环境, 角色.战斗开始被动技能选择);
                }

                if (角色.隐藏技能 != null && 角色.隐藏技能 is 战斗开始被动技能)
                {
                    战斗开始被动技能 战斗开始被动技能 = (战斗开始被动技能)角色.隐藏技能;
                    if (战斗开始被动技能.是否唯一)
                    {
                        if (唯一被动List.Contains(战斗开始被动技能.Name))
                            continue;

                        唯一被动List.Add(战斗开始被动技能.Name);
                    }
                    
                    技能环境 技能环境 = createEnvironment(角色, true, new List<角色>() { 角色 }, 角色.隐藏技能.Name);
                    战斗开始被动技能.Excute(技能环境);
                }
            }

            //初始化行动顺序
            List<角色> list = new List<角色>(战场.队伍状态1.队伍.成员List);
            list.AddRange(战场.队伍状态2.队伍.成员List);
            战场.行动顺序.初始化行动表(list, 战场.乱数表);

            waitReady();
        }

        private void nextAction()
        {
            //判断是否完结
            if (战场.当前回合 == 战场.最大回合数 ||
                战场.队伍状态1.是否败退 ||
                战场.队伍状态2.是否败退 ||
                (战场.队伍状态1.是否行动结束 && 战场.队伍状态2.是否行动结束))
            {
                end();
                return;
            }

            var 角色 = 战场.行动顺序.List[0];
            ActionEventArgs args = new ActionEventArgs();
            args.角色 = new 角色Struct() { ID = 角色.ID, Name = 角色.Name };
            args.技能List = new List<Data技能>();

            队伍状况 队伍状态 = 角色.是否队伍1 ? 战场.队伍状态1 : 战场.队伍状态2;

            if (角色.基础攻击技能 != null)
            {
                Data技能 data技能 = cal技能(角色.基础攻击技能, 队伍状态, 角色);
                args.技能List.Add(data技能);
            }

            if (角色.技能1 != null)
            {
                Data技能 data技能 = cal技能(角色.技能1, 队伍状态, 角色);
                args.技能List.Add(data技能);
            }

            if (角色.技能2 != null)
            {
                Data技能 data技能 = cal技能(角色.技能2, 队伍状态, 角色);
                args.技能List.Add(data技能);
            }

            if (角色.待机 != null)
            {
                Data技能 data技能 = cal技能(角色.待机, 队伍状态, 角色);
                args.技能List.Add(data技能);
            }

            if (角色.是否准备)
            {
                List<Guid> list = new List<Guid>();
                foreach (var item in 角色.准备技能.准备技能目标List)
                    if (!item.是否败退)
                        list.Add(item.ID);

                Action(角色.ID, 角色.准备技能.Name, list);
            }
            else
            {
                var list = args.技能List.FindAll(s => s.Effective);

                //正式游戏中,不待"帮"玩家待机
                if (list.Count == 1 && list[0].Name == "待机")
                {
                    Action(角色.ID, "待机", new List<Guid>() { 角色.ID });
                }
                else
                {
                    if (角色.是否队伍1)
                    {
                        if (!战场.队伍状态1.IsUser || 战场.队伍状态1.IsControlByComputer)
                        {
                            if (list.Count == 1 && list[0].Name == "待机")
                            {
                                Action(角色.ID, "待机", new List<Guid>() { 角色.ID });
                            }

                            //电脑AI

                            AI ai = getAI(角色.AI);
                            AI技能MGT 技能Mgt = new AI技能MGT(args.技能List, 战场.队伍状态1);
                            var aiResult = ai.Excute(角色, 战场.队伍状态1, 技能Mgt);
                            if (aiResult == null)
                                Action(角色.ID, "待机", new List<Guid>() { 角色.ID });
                            else
                            {
                                List<Guid> targetList = new List<Guid>();
                                foreach (var item in aiResult.TargetList)
                                    targetList.Add(item.ID);

                                Action(角色.ID, aiResult.Action, targetList);
                            }
                        }
                        else
                        {
                            if (Team1ActionEvent != null)
                            {
                                args.IsSelf = 角色.是否队伍1;
                                Team1ActionEvent(null, args);
                            }
                        }
                    }
                    else
                    {
                        if (!战场.队伍状态2.IsUser || 战场.队伍状态2.IsControlByComputer)
                        {
                            if (list.Count == 1 && list[0].Name == "待机")
                            {
                                Action(角色.ID, "待机", new List<Guid>() { 角色.ID });
                            }

                            //电脑AI

                            AI ai = getAI(角色.AI);
                            AI技能MGT 技能Mgt = new AI技能MGT(args.技能List, 战场.队伍状态2);
                            var aiResult = ai.Excute(角色, 战场.队伍状态2, 技能Mgt);
                            if (aiResult == null)
                                Action(角色.ID, "待机", new List<Guid>() { 角色.ID });
                            else
                            {
                                List<Guid> targetList = new List<Guid>();
                                foreach (var item in aiResult.TargetList)
                                    targetList.Add(item.ID);

                                Action(角色.ID, aiResult.Action, targetList);
                            }
                        }
                        else
                        {
                            if (Team2ActionEvent != null)
                            {
                                args.IsSelf = !角色.是否队伍1;
                                Team2ActionEvent(null, args);
                            }
                        }
                    }
                }
            }
        }

        private AI getAI(string ai)
        {
            Type type = Type.GetType("Rance.Battle." + ai);
            var method = type.GetMethod("GetInstance", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
            return method.Invoke(null, null) as AI;
        }

        private void end()
        {
            战场.IsEnd = true;
            if (战场.队伍状态1.是否败退 && 战场.队伍状态2.是否败退)
            {
                战场.队伍状态1.战斗胜负 = Data战斗胜负.平;
                战场.队伍状态2.战斗胜负 = Data战斗胜负.平;
            }
            else if (战场.队伍状态1.是否败退)
            {
                战场.队伍状态1.战斗胜负 = Data战斗胜负.负;
                战场.队伍状态2.战斗胜负 = Data战斗胜负.胜;
            }
            else if (战场.队伍状态2.是否败退)
            {
                战场.队伍状态1.战斗胜负 = Data战斗胜负.胜;
                战场.队伍状态2.战斗胜负 = Data战斗胜负.负;
            }
            else if (战场.队伍状态1.战果 == 0)
            {
                战场.队伍状态1.战斗胜负 = Data战斗胜负.平;
                战场.队伍状态2.战斗胜负 = Data战斗胜负.平;
            }
            else if (战场.队伍状态1.战果 > 0)
            {
                战场.队伍状态1.战斗胜负 = Data战斗胜负.胜;
                战场.队伍状态2.战斗胜负 = Data战斗胜负.负;
            }
            else
            {
                战场.队伍状态1.战斗胜负 = Data战斗胜负.负;
                战场.队伍状态2.战斗胜负 = Data战斗胜负.胜;
            }

            if (战场.队伍状态1.IsUser)
            {
                Data战斗结果 战斗结果 = new Data战斗结果();
                战斗结果.战斗胜负 = 战场.队伍状态1.战斗胜负;

                if (战斗结果.战斗胜负 == Data战斗胜负.胜)
                {
                    foreach (var 角色 in 战场.队伍状态1.队伍.成员List)
                    {
                        if (!角色.是否败退)
                        {
                            int value = Convert.ToInt32(角色.最大兵力 * 常量.战斗后回复系数 / 100m);
                            if (value + 角色.兵力 > 角色.最大兵力)
                                value = 角色.最大兵力 - 角色.兵力;

                            角色.兵力 += value;

                            if (value > 0)
                                战斗结果.List.Add(new Data战斗结果恢复Detail() { 角色 = new 角色Struct() { ID = 角色.ID, Name = 角色.Name }, 恢复量 = value });
                        }
                    }
                }

                foreach (var 角色 in 战场.队伍状态1.队伍.成员List)
                {
                    if (!角色.是否败退)
                    {
                        if (角色.被动技能 != null && 角色.被动技能 is 战斗结束被动技能)
                        {
                            战斗结束被动技能 战斗结束被动技能 = (战斗结束被动技能)角色.被动技能;
                            战斗结束被动技能.Excute(战斗结果, 角色);
                        }
                    }
                }

                if (Team1WarEndEvent != null)
                    Team1WarEndEvent(null, new WarEndEventArgs() { Data战斗结果 = 战斗结果 });
            }

            if (战场.队伍状态2.IsUser)
            {
                Data战斗结果 战斗结果 = new Data战斗结果();
                战斗结果.战斗胜负 = 战场.队伍状态2.战斗胜负;

                if (战斗结果.战斗胜负 == Data战斗胜负.胜)
                {
                    foreach (var 角色 in 战场.队伍状态2.队伍.成员List)
                    {
                        if (!角色.是否败退)
                        {
                            int value = Convert.ToInt32(角色.最大兵力 * 常量.战斗后回复系数 / 100m);
                            if (value + 角色.兵力 > 角色.最大兵力)
                                value = 角色.最大兵力 - 角色.兵力;

                            角色.兵力 += value;

                            if (value > 0)
                                战斗结果.List.Add(new Data战斗结果恢复Detail() { 角色 = new 角色Struct() { ID = 角色.ID, Name = 角色.Name }, 恢复量 = value });
                        }
                    }
                }

                foreach (var 角色 in 战场.队伍状态2.队伍.成员List)
                {
                    if (!角色.是否败退)
                    {
                        if (角色.被动技能 != null && 角色.被动技能 is 战斗结束被动技能)
                        {
                            战斗结束被动技能 战斗结束被动技能 = (战斗结束被动技能)角色.被动技能;
                            战斗结束被动技能.Excute(战斗结果, 角色);
                        }
                    }
                }

                if (Team2WarEndEvent != null)
                    Team2WarEndEvent(null, new WarEndEventArgs() { Data战斗结果 = 战斗结果 });
            }
        }

        private Data技能 cal技能(主动技能 技能, 队伍状况 队伍状态, 角色 角色)
        {
            Data技能 data技能 = new Data技能();
            data技能.Name = 技能.Name;
            switch (技能.消耗行动点)
            {
                case 消耗行动点.无消耗:
                    data技能.行动点 = 0;
                    break;
                case 消耗行动点.一点:
                    data技能.行动点 = 1;
                    break;
                case 消耗行动点.两点:
                    data技能.行动点 = 2;
                    break;
                case 消耗行动点.三点:
                    data技能.行动点 = 3;
                    break;
                case 消耗行动点.全部:
                    data技能.行动点 = 角色.行动点;
                    break;
            }

            data技能.目标List = new List<Data技能目标>();
            data技能.Effective = data技能.行动点 <= 角色.行动点;
            if (data技能.行动点 <= 角色.行动点)
            {
                switch (技能.技能站位要求)
                {
                    case 技能站位要求.无:
                        break;
                    case 技能站位要求.前列:
                        队伍状态.队伍.成员List.Sort((v1, v2) => v1.列.CompareTo(v2.列));
                        var 最前列 = 队伍状态.队伍.成员List.Find(u => !u.是否败退).列;
                     
                        if (角色.列 != 最前列)
                            data技能.Effective = false;
                        break;
                    case 技能站位要求.后列:
                        队伍状态.队伍.成员List.Sort((v1, v2) => v1.列.CompareTo(v2.列));
                        最前列 = 队伍状态.队伍.成员List.Find(u => !u.是否败退).列;
                                                
                        if (角色.列 == 最前列)
                            data技能.Effective = false;
                        break;
                }

                if (data技能.Effective)
                {
                    List<角色Struct> temp = null;
                    switch (技能.技能目标)
                    {
                        case 技能目标._2X2:
                            var temp2 = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退);
                                         
                            foreach (var item in temp2)
                            {
                                Data技能目标 data技能目标 = new Data技能目标();
                                data技能目标.角色 = new 角色Struct() { ID = item.ID, Name = item.Name };
                                if (item.排 == 3)
                                {
                                    var tempList = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退 && u.排 >= 2);
                                    foreach (var tempItem in tempList)
                                        data技能目标.连带角色List.Add(new 角色Struct()
                                                                     {
                                                                         ID = tempItem.ID,
                                                                         Name = tempItem.Name
                                                                     });

                                }
                                else
                                {
                                    var tempList = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退 && u.排 <= 2);
                                    foreach (var tempItem in tempList)
                                        data技能目标.连带角色List.Add(new 角色Struct()
                                                                     {
                                                                         ID = tempItem.ID,
                                                                         Name = tempItem.Name
                                                                     });
                                }

                                data技能.目标List.Add(data技能目标);
                            }
                            break;
                        case 技能目标.除自己以外己方任一:
                            var tempList2 = 队伍状态.队伍.成员List.FindAll(u => !u.是否败退 && u.ID != 角色.ID);
                            foreach (var item in tempList2)
                            {
                                Data技能目标 data技能目标 = new Data技能目标();
                                data技能目标.角色 = new 角色Struct()
                                                {
                                                    ID = item.ID,
                                                    Name = item.Name
                                                };
                                data技能目标.连带角色List.Add(data技能目标.角色);
                                data技能.目标List.Add(data技能目标);
                            }
                            break;
                        case 技能目标.己方全体:
                            tempList2 = 队伍状态.队伍.成员List.FindAll(u => !u.是否败退);
                            temp = new List<角色Struct>();
                            foreach (var item in tempList2)
                                temp.Add(new 角色Struct()
                                                {
                                                    ID = item.ID,
                                                    Name = item.Name
                                                });
                        ;
                            foreach (var item in temp)
                            {
                                Data技能目标 data技能目标 = new Data技能目标();
                                data技能目标.角色 = item;
                                data技能目标.连带角色List = temp;
                                data技能.目标List.Add(data技能目标);
                            }
                            break;
                        case 技能目标.己方任一:
                            tempList2 = 队伍状态.队伍.成员List.FindAll(u => !u.是否败退);
                            foreach (var item in tempList2)
                            {
                                Data技能目标 data技能目标 = new Data技能目标();
                                data技能目标.角色 = new 角色Struct()
                                                {
                                                    ID = item.ID,
                                                    Name = item.Name
                                                };
                                data技能目标.连带角色List.Add(data技能目标.角色);
                                data技能.目标List.Add(data技能目标);
                            }
                            break;
                        case 技能目标.全体:
                            tempList2 = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退);
                            temp = new List<角色Struct>();
                            foreach (var item in tempList2)
                                temp.Add(new 角色Struct()
                                                {
                                                    ID = item.ID,
                                                    Name = item.Name
                                                });
                        ;
                            foreach (var item in temp)
                            {
                                Data技能目标 data技能目标 = new Data技能目标();
                                data技能目标.角色 = item;
                                data技能目标.连带角色List = temp;
                                data技能.目标List.Add(data技能目标);
                            }
                            break;
                        case 技能目标.全体任一:
                            tempList2 = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退);
                            foreach (var item in tempList2)
                            {
                                Data技能目标 data技能目标 = new Data技能目标();
                                data技能目标.角色 = new 角色Struct()
                                                {
                                                    ID = item.ID,
                                                    Name = item.Name
                                                };
                                data技能目标.连带角色List.Add(data技能目标.角色);
                                data技能.目标List.Add(data技能目标);
                            }
                            break;
                        case 技能目标.同排全体:
                            if (角色.排 == 1)
                            {
                                tempList2 = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退 && u.排 == 3);
                                temp = new List<角色Struct>();
                                foreach (var item in tempList2)
                                    temp.Add(new 角色Struct()
                                                    {
                                                        ID = item.ID,
                                                        Name = item.Name
                                                    });
                                                                  
                            }
                            else if (角色.排 == 2)
                            {
                                tempList2 = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退 && u.排 == 2);
                                temp = new List<角色Struct>();
                                foreach (var item in tempList2)
                                    temp.Add(new 角色Struct()
                                                    {
                                                        ID = item.ID,
                                                        Name = item.Name
                                                    });
                                                           
                            }
                            else if (角色.排 == 3)
                            {
                                tempList2 = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退 && u.排 == 1);
                                temp = new List<角色Struct>();
                                foreach (var item in tempList2)
                                    temp.Add(new 角色Struct()
                                    {
                                        ID = item.ID,
                                        Name = item.Name
                                    });
                            }

                            foreach (var item in temp)
                            {
                                Data技能目标 data技能目标 = new Data技能目标();
                                data技能目标.角色 = item;
                                data技能目标.连带角色List = temp;
                                data技能.目标List.Add(data技能目标);
                            }
                            break;
                        case 技能目标.一排全体:
                            temp2 = 队伍状态.对手状态.队伍.成员List.FindAll( u=> !u.是否败退);
                            foreach (var item in temp2)
                            {
                                Data技能目标 data技能目标 = new Data技能目标();
                                data技能目标.角色 = new 角色Struct() { ID = item.ID, Name = item.Name };
                                var tempList = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退 && u.排 == item.排);
                                foreach (var tempItem in tempList)
                                    data技能目标.连带角色List.Add(new 角色Struct()
                                                     {
                                                         ID = tempItem.ID,
                                                         Name = tempItem.Name
                                                     });
                                data技能.目标List.Add(data技能目标);
                            }
                            break;
                        case 技能目标.战场:
                        case 技能目标.自己:
                            Data技能目标 data技能目标_自己 = new Data技能目标();
                            data技能目标_自己.角色 = new 角色Struct() { ID = 角色.ID, Name = 角色.Name };
                            data技能目标_自己.连带角色List.Add(data技能目标_自己.角色);
                            data技能.目标List.Add(data技能目标_自己);
                            break;
                        case 技能目标.最前列任一:
                            队伍状态.对手状态.队伍.成员List.Sort((v1,v2) => v1.列.CompareTo(v2.列));
                            var 最前列 = 队伍状态.对手状态.队伍.成员List.Find(u => !u.是否败退).列;
                            if (最前列 != 0)
                            {
                                var tempList = 队伍状态.对手状态.队伍.成员List.FindAll(u => !u.是否败退 && u.列 == 最前列);
                                foreach (var item in tempList)
                                {
                                    Data技能目标 data技能目标 = new Data技能目标();
                                    data技能目标.角色 = new 角色Struct()
                                        {
                                            ID = item.ID,
                                            Name = item.Name
                                        };
                                    data技能目标.连带角色List.Add(data技能目标.角色);
                                    data技能.目标List.Add(data技能目标);
                                }
                            }
                            break;
                    }
                }
            }

            data技能.Effective = data技能.目标List.Count > 0;

            return data技能;
        }



        private 技能环境 createEnvironment(角色 施法者, bool 是否队伍1, List<角色> targetList, string 技能)
        {
            技能环境 技能环境 = new 技能环境()
            {
                施放者 = 施法者,
                目标List = targetList,
                是否队伍1 = 是否队伍1,
            };
            if (是否队伍1)
                技能环境.队伍状况 = 战场.队伍状态1;
            else
                技能环境.队伍状况 = 战场.队伍状态2;

            技能环境.行动结果 = new Data行动结果();
            技能环境.行动结果.角色 = new 角色Struct() { ID = 施法者.ID, Name = 施法者.Name };
            技能环境.行动结果.技能 = 技能;
            技能环境.行动结果.是否己方 = true;

            return 技能环境;
        }

        private void actionError()
        {
            return;
        }

        //public 队伍状况 Get状态(Guid id)
        //{
        //    if (战场.队伍状态1.ID == id)
        //        return 战场.队伍状态1;
        //    else if (战场.队伍状态2.ID == id)
        //        return 战场.队伍状态2;
        //    else
        //        return null;
        //}

        internal static 角色  Create(string name, string 兵种, int 攻, int 防, int 智, int 速, int 行动点, int 兵力, int 最大兵力, int 排, int 列, string 基础攻击技能, string 技能1, string 技能2, string 被动技能, string 隐藏技能, string 战斗开始被动技能选择, bool 特殊人物, string 装备,string AI)
        {
            角色 角色 = new 角色()
            {
                Name = name,
                攻 = 攻,
                临时攻 = 攻,
                防 = 防,
                临时防 = 防,
                速 = 速,
                临时速 = 速,
                智 = 智,
                临时智 = 智,
                行动点 = 行动点,
                最大行动点 = 行动点,
                兵力 = 兵力,
                最大兵力 = 最大兵力,
                排 = 排,
                列 = 列,
                特殊人物 = 特殊人物
            };
            switch (兵种)
            {
                case "剑士":
                    角色.兵种 = Battle.兵种.剑士;
                    break;
                case "步卒":
                    角色.兵种 = Battle.兵种.步卒;
                    break;
                case "火枪":
                    角色.兵种 = Battle.兵种.火枪;
                    break;
                case "战车":
                    角色.兵种 = Battle.兵种.战车;
                    break;
                case "侠客":
                    角色.兵种 = Battle.兵种.侠客;
                    break;
                case "军师":
                    角色.兵种 = Battle.兵种.军师;
                    break;
                case "策士":
                    角色.兵种 = Battle.兵种.策士;
                    break;
                case "弓兵":
                    角色.兵种 = Battle.兵种.弓兵;
                    break;
                case "炮兵":
                    角色.兵种 = Battle.兵种.炮兵;
                    break;
                case "骑兵":
                    角色.兵种 = Battle.兵种.骑兵;
                    break;
                case "巫师":
                    角色.兵种 = Battle.兵种.巫师;
                    break;
                case "军乐队":
                    角色.兵种 = Battle.兵种.军乐队;
                    break;
            }

            if (!string.IsNullOrEmpty(基础攻击技能))
                角色.基础攻击技能 = create技能(基础攻击技能) as 主动技能;
            if (!string.IsNullOrEmpty(技能1))
                角色.技能1 = create技能(技能1) as 主动技能;
            if (!string.IsNullOrEmpty(技能2))
                角色.技能2 = create技能(技能2) as 主动技能;
            if (!string.IsNullOrEmpty(被动技能))
                角色.被动技能 = create技能(被动技能) as 被动技能;
            if (!string.IsNullOrEmpty(隐藏技能))
                角色.隐藏技能 = create技能(隐藏技能) as 被动技能;

            角色.战斗开始被动技能选择 = 战斗开始被动技能选择;
            角色.待机 = 待机.Instance;
            角色.装备 = 装备;

            set装备(角色);

            if (AI == null)
                角色.AI = 角色.兵种.Name + "AI";
            else
                角色.AI = AI;

            return 角色;
        }

        private static void set装备(角色 角色)
        {
            switch (角色.装备)
            {
                case "吴钩":
                    角色.攻++;
                    break;
                case "小圆盾":
                    角色.防++;
                    break;
                case "六韬":
                    角色.智++;
                    break;
                case "追风":
                    角色.速++;
                    break;
                case "冥山弓":
                    角色.物理额外伤害 += 20;
                    break;
                case "护心镜":
                    角色.物理减伤 += 30;
                    break;
                case "令旗":
                    角色.兵力 += 80;
                    角色.最大兵力 += 80;
                    break;
                case "纯钧":
                    角色.攻 += 2;
                    break;
                case "胜邪":
                    角色.攻++;
                    角色.防++;
                    break;
                case "月华弓":
                    角色.物理额外伤害 += 50;
                    break;
                case "落日弓":
                    角色.物理额外伤害 += 80;
                    break;
                case "鱼肠":
                    角色.攻++;
                    角色.速++;
                    break;
                case "燕尾方盾":
                    角色.防 += 2;
                    break;
                case "青铜护甲":
                    角色.物理减伤 += 60;
                    break;
                case "楚骓":
                    角色.速 += 2;
                    break;
                case "赤骥":
                    角色.速++;
                    角色.防++;
                    break;
                case "孙子兵法":
                    角色.智 += 2;
                    break;
                case "鹰符":
                    角色.兵力 += 150;
                    角色.最大兵力 += 150;
                    break;
                case "虎符":
                    角色.兵力 += 200;
                    角色.最大兵力 += 200;
                    break;
                case "龙符":
                    角色.兵力 += 300;
                    角色.最大兵力 += 300;
                    break;
                case "晨凫":
                    角色.速 += 2;
                    角色.防++;
                    break;
                case "飞翩":
                    角色.速 += 2;
                    角色.攻++;
                    break;
                case "华骝":
                    角色.速 += 2;
                    角色.智++;
                    break;
                case "干将":
                    角色.攻 += 2;
                    角色.防++;
                    break;
                case "湛卢":
                    角色.攻++;
                    角色.防++;
                    角色.速++;
                    break;
                case "诸侯信印":
                    角色.道具自动恢复 = 30;
                    break;
                case "天子令旗":
                    角色.道具自动恢复 = 50;
                    break;
            }

            if (角色.攻 > 9)
                角色.攻 = 9;
            if (角色.防 > 9)
                角色.防 = 9;
            if (角色.速 > 9)
                角色.速 = 9;
            if (角色.智 > 9)
                角色.智 = 9;
            if (角色.最大行动点 > 6)
                角色.最大行动点 = 6;
        }

        private static 技能 create技能(string 技能名)
        {
            Type type = Type.GetType("Rance.Battle." + 技能名);
            return MethodCaller.CreateInstance(type) as 技能;
        }

        #endregion

        #region Old

        //public 战斗管理()
        //{

        //}

        //private 战场 teamA战场;

        //public 战场 Get战场(bool isTeamA)
        //{
        //    if (isTeamA)
        //        return teamA战场;
        //    else
        //        return teamA战场.反转();
        //}

        //public static 角色 Create(string name, string 兵种, int 攻, int 防, int 智, int 速, int 行动点, int 兵力, int 最大兵力, int 排, int 列, string 基础攻击技能, string 技能1, string 技能2, string 被动技能, string 隐藏技能, bool 特殊人物)
        //{
        //    角色 角色 = new 角色()
        //    {
        //        Name = name,
        //        攻 = 攻,
        //        临时攻 = 攻,
        //        防 = 防,
        //        临时防 = 防,
        //        速 = 速,
        //        临时速 = 速,
        //        智 = 智,
        //        临时智 = 智,
        //        行动点 = 行动点,
        //        最大行动点 = 行动点,
        //        兵力 = 兵力,
        //        最大兵力 = 最大兵力,
        //        排 = 排,
        //        列 = 列,
        //        特殊人物 = 特殊人物
        //    };
        //    switch (兵种)
        //    {
        //        case "剑士":
        //            角色.兵种 = Battle.兵种.剑士;
        //            break;
        //        case "步卒":
        //            角色.兵种 = Battle.兵种.步卒;
        //            break;
        //        case "火枪":
        //            角色.兵种 = Battle.兵种.火枪;
        //            break;
        //        case "战车":
        //            角色.兵种 = Battle.兵种.战车;
        //            break;
        //        case "侠客":
        //            角色.兵种 = Battle.兵种.侠客;
        //            break;
        //        case "军师":
        //            角色.兵种 = Battle.兵种.军师;
        //            break;
        //        case "策士":
        //            角色.兵种 = Battle.兵种.策士;
        //            break;
        //        case "弓兵":
        //            角色.兵种 = Battle.兵种.弓兵;
        //            break;
        //        case "炮兵":
        //            角色.兵种 = Battle.兵种.炮兵;
        //            break;
        //        case "骑兵":
        //            角色.兵种 = Battle.兵种.骑兵;
        //            break;
        //        case "巫师":
        //            角色.兵种 = Battle.兵种.巫师;
        //            break;
        //        case "军乐队":
        //            角色.兵种 = Battle.兵种.军乐队;
        //            break;
        //    }

        //    if (!string.IsNullOrEmpty(基础攻击技能))
        //        角色.基础攻击技能 = create技能(基础攻击技能) as 主动技能;
        //    if (!string.IsNullOrEmpty(技能1))
        //        角色.技能1 = create技能(技能1) as 主动技能;
        //    if (!string.IsNullOrEmpty(技能2))
        //        角色.技能2 = create技能(技能2) as 主动技能;
        //    if (!string.IsNullOrEmpty(被动技能))
        //        角色.被动技能 = create技能(被动技能) as 被动技能;
        //    if (!string.IsNullOrEmpty(隐藏技能))
        //        角色.隐藏技能 = create技能(隐藏技能) as 被动技能;

        //    角色.待机 = 待机.Instance;


        //    return 角色;
        //}



        //public void Init(队伍 teamA, 队伍 teamB, 战地类型 战地类型)
        //{
        //    teamA战场 = new 战场();
        //    teamA战场.当前回合 = 1;
        //    teamA战场.最大回合数 = 30;
        //    teamA战场.己方角色List = teamA.成员List;
        //    foreach (var 角色 in teamA.成员List)
        //        角色.是否队伍1 = true;
        //    teamA战场.敌方角色List = teamB.成员List;
        //    foreach (var 角色 in teamB.成员List)
        //        角色.是否队伍1 = false;
        //    teamA战场.己方队伍名称 = teamA.Name;
        //    teamA战场.敌方队伍名称 = teamB.Name;
        //    teamA战场.乱数表 = new 乱数表();
        //    switch (战地类型)
        //    {
        //        case Battle.战地类型.野战:
        //            teamA战场.战场修正 = 0;
        //            teamA战场.战果 = 0;
        //            break;
        //        case Battle.战地类型.防守_城市:
        //            teamA战场.战场修正 = 20;
        //            teamA战场.战果 = 500;
        //            break;
        //        case Battle.战地类型.防守_小镇:
        //            teamA战场.战场修正 = 12;
        //            teamA战场.战果 = 200;
        //            break;
        //        case Battle.战地类型.防守_山寨:
        //            teamA战场.战场修正 = 4;
        //            teamA战场.战果 = 0;
        //            break;
        //        case Battle.战地类型.进攻_城市:
        //            teamA战场.战场修正 = -20;
        //            teamA战场.战果 = -500;
        //            break;
        //        case Battle.战地类型.进攻_小镇:
        //            teamA战场.战场修正 = -12;
        //            teamA战场.战果 = -200;
        //            break;
        //        case Battle.战地类型.进攻_山寨:
        //            teamA战场.战场修正 = -4;
        //            teamA战场.战果 = 0;
        //            break;
        //    }

        //    List<角色> list = new List<角色>(teamA.成员List);
        //    list.AddRange(teamB.成员List);
        //    teamA战场.行动顺序 = new 行动顺序();
        //    teamA战场.行动顺序.初始化行动表(list, teamA战场.乱数表);

        //    foreach (var 角色 in teamA战场.己方角色List)
        //    {
        //        if (角色.被动技能 != null && 角色.被动技能 is 战斗开始被动技能)
        //        {
        //            战斗开始被动技能 战斗开始被动技能 = (战斗开始被动技能)角色.被动技能;
        //            技能环境 技能环境 = createEnvironment(角色, true, new List<角色>() { 角色 });
        //            战斗开始被动技能.Excute(技能环境);
        //        }

        //        if (角色.隐藏技能 != null && 角色.隐藏技能 is 战斗开始被动技能)
        //        {
        //            战斗开始被动技能 战斗开始被动技能 = (战斗开始被动技能)角色.隐藏技能;
        //            技能环境 技能环境 = createEnvironment(角色, true, new List<角色>() { 角色 });
        //            战斗开始被动技能.Excute(技能环境);
        //        }
        //    }

        //    foreach (var 角色 in teamA战场.敌方角色List)
        //    {
        //        if (角色.被动技能 != null && 角色.被动技能 is 战斗开始被动技能)
        //        {
        //            战斗开始被动技能 战斗开始被动技能 = (战斗开始被动技能)角色.被动技能;
        //            技能环境 技能环境 = createEnvironment(角色, false, new List<角色>() { 角色 });
        //            战斗开始被动技能.Excute(技能环境);
        //        }

        //        if (角色.隐藏技能 != null && 角色.隐藏技能 is 战斗开始被动技能)
        //        {
        //            战斗开始被动技能 战斗开始被动技能 = (战斗开始被动技能)角色.隐藏技能;
        //            技能环境 技能环境 = createEnvironment(角色, false, new List<角色>() { 角色 });
        //            战斗开始被动技能.Excute(技能环境);
        //        }
        //    }
        //}


        ////public 行动者 GetNextRole()
        ////{
        ////    if (this.teamA战场.IsEnd)
        ////        throw new Exception("战斗已经结束");
        ////    角色 角色 = this.teamA战场.行动顺序.List[0];
        ////    角色.本回合法术减伤 = 角色.法术减伤;
        ////    角色.本回合物理穿透 = 角色.物理穿透;
        ////    角色.本回合物理额外伤害 = 角色.物理额外伤害;
        ////    角色.本回合物理减伤 = 角色.物理减伤;


        ////    行动者 行动者 = new 行动者()
        ////    {
        ////        角色 = 角色,
        ////        IsTeamA = teamA战场.己方角色List.Contains(角色)
        ////    };
        ////    return 行动者;
        ////}

        //public List<ActionResult> Action(角色 角色, string action, List<角色> targetList)
        //{
        //    if (this.teamA战场.行动顺序.List[0] != 角色)
        //        throw new Exception("不是这个角色的行动轮");

        //    角色.临时攻 = 角色.攻;
        //    角色.临时防 = 角色.防;
        //    角色.临时速 = 角色.速;
        //    角色.临时智 = 角色.智;

        //    技能环境 技能环境 = createEnvironment(角色, teamA战场.己方角色List.Contains(角色), targetList);
        //    if (action == "待机")
        //    {
        //        角色.待机.Excute(技能环境);
        //    }
        //    else
        //    {
        //        if ((角色.技能1 != null && 角色.技能1.Name != action) &&
        //            (角色.技能2 != null && 角色.技能2.Name != action) &&
        //            (角色.基础攻击技能 != null && 角色.基础攻击技能.Name != action))
        //        {
        //            throw new Exception("没有这个技能!");
        //        }

        //        主动技能 技能 = create技能(action) as 主动技能;
        //        if (技能 == null)
        //            throw new Exception("没有这个技能!");

        //        foreach (var 效果 in 角色.效果List.ToArray())
        //        {
        //            if (效果 is 技能效果)
        //            {
        //                技能效果 技能效果 = 效果 as 技能效果;
        //                var result = 技能效果.Excute(技能);
        //                if (效果.持续类型 == 持续类型.一次 && result)
        //                    角色.效果List.Remove(效果);
        //            }
        //        }

        //        技能.Excute(技能环境);
        //        switch (技能.消耗行动点)
        //        {
        //            case 消耗行动点.无消耗:
        //                break;
        //            case 消耗行动点.一点:
        //                角色.行动点--;
        //                break;
        //            case 消耗行动点.两点:
        //                角色.行动点 -= 2;
        //                break;
        //            case 消耗行动点.三点:
        //                角色.行动点 -= 3;
        //                break;
        //            case 消耗行动点.全部:
        //                角色.行动点 = 0;
        //                break;
        //        }
        //    }


        //    if (角色.行动点 < 0)
        //        角色.行动点 = 0;
        //    if (teamA战场.战果 > 常量.最大战果)
        //        teamA战场.战果 = 常量.最大战果;
        //    if (teamA战场.战果 < 常量.最小战果)
        //        teamA战场.战果 = 常量.最小战果;
        //    if (teamA战场.战场修正 > 常量.最大战场修正)
        //        teamA战场.战场修正 = 常量.最大战场修正;
        //    if (teamA战场.战场修正 < 常量.最小战场修正)
        //        teamA战场.战场修正 = 常量.最小战场修正;

        //    foreach (var 效果 in 角色.效果List.ToArray())
        //    {
        //        if (效果.持续类型 == 持续类型.一回合)
        //        {
        //            if (效果.回合数 == 0)
        //                效果.回合数++;
        //            else if (效果.回合数 == 1)
        //                角色.效果List.Remove(效果);
        //        }
        //    }

        //    if (角色.行动点 == 0)
        //        角色.是否完结 = true;

        //    if (teamA战场.当前回合 >= teamA战场.最大回合数)
        //    {
        //        teamA战场.当前回合 = teamA战场.最大回合数;
        //        teamA战场.IsEnd = true;
        //    }

        //    if (角色.被动技能 is 自己回合结束被动技能)
        //    {
        //        自己回合结束被动技能 自己回合结束被动技能 = (自己回合结束被动技能)角色.被动技能;
        //        自己回合结束被动技能.Excute(技能环境, 角色);
        //    }

        //    bool isAllDead = true;
        //    foreach (var item in teamA战场.己方角色List)
        //    {
        //        if (!item.是否败退)
        //        {
        //            isAllDead = false;
        //            if (item.被动技能 is 回合结束被动技能)
        //            {
        //                回合结束被动技能 回合结束被动技能 = (回合结束被动技能)item.被动技能;
        //                回合结束被动技能.Excute(技能环境, item);
        //            }
        //            break;
        //        }
        //    }
        //    if (isAllDead)
        //    {
        //        teamA战场.IsEnd = true;
        //        teamA战场.战果 = -1000;
        //    }
        //    else
        //    {
        //        isAllDead = true;
        //        foreach (var item in teamA战场.敌方角色List)
        //        {
        //            if (!item.是否败退)
        //            {
        //                isAllDead = false;
        //                if (item.被动技能 is 回合结束被动技能)
        //                {
        //                    回合结束被动技能 回合结束被动技能 = (回合结束被动技能)item.被动技能;
        //                    回合结束被动技能.Excute(技能环境, item);
        //                }
        //                break;
        //            }
        //        }

        //        if (isAllDead)
        //        {
        //            teamA战场.IsEnd = true;
        //            teamA战场.战果 = 1000;
        //        }
        //    }

        //    if (角色.自动恢复 > 0)
        //    {
        //        角色.兵力 += 角色.自动恢复;
        //        if (角色.兵力 > 角色.最大兵力)
        //            角色.兵力 = 角色.最大兵力;
        //    }

        //    技能环境.队伍状况.战场.当前回合++;
        //    if (teamA战场.当前回合 >= teamA战场.最大回合数)
        //        teamA战场.IsEnd = true;

        //    if (teamA战场.行动顺序.List.Count == 0)
        //        teamA战场.IsEnd = true;

        //    if (!teamA战场.己方角色List.Contains(角色))
        //        teamA战场.反转Save();


        //    if (!teamA战场.IsEnd)
        //    {
        //        var next角色 = teamA战场.行动顺序.List[0];
        //        if (next角色.攻击赋予 != null && next角色.攻击赋予.是否单回合)
        //            next角色.攻击赋予.回合数++;
        //        if (next角色.防御赋予 != null && next角色.防御赋予.是否单回合)
        //            next角色.防御赋予.回合数++;
        //        if (next角色.速度赋予 != null && next角色.速度赋予.是否单回合)
        //            next角色.速度赋予.回合数++;
        //        if (next角色.智力赋予 != null && next角色.智力赋予.是否单回合)
        //            next角色.智力赋予.回合数++;
        //    }

        //    return 技能环境.行动结果.行动结果DetailList;
        //}

        //public List<战斗结果> 战斗结算()
        //{
        //    if (!teamA战场.IsEnd)
        //        throw new Exception("战斗还没结束");

        //    战斗结果 teamA战斗结果 = new 战斗结果();
        //    战斗结果 teamB战斗结果 = new 战斗结果();

        //    bool isTeamA团灭 = true;
        //    bool isTeamB团灭 = true;
        //    bool isTeamAWin = false;
        //    foreach (var item in teamA战场.己方角色List)
        //    {
        //        if (!item.是否败退)
        //        {
        //            isTeamA团灭 = false;
        //            break;
        //        }
        //    }
        //    foreach (var item in teamA战场.敌方角色List)
        //    {
        //        if (!item.是否败退)
        //        {
        //            isTeamB团灭 = false;
        //            break;
        //        }
        //    }
        //    if (isTeamA团灭)
        //        isTeamAWin = false;
        //    else if (isTeamB团灭)
        //        isTeamAWin = true;
        //    else
        //        isTeamAWin = teamA战场.战果 > 0;

        //    teamA战斗结果.角色List = teamA战场.己方角色List;
        //    teamB战斗结果.角色List = teamA战场.敌方角色List;
        //    teamA战斗结果.回复兵力List = new List<int>();
        //    teamB战斗结果.回复兵力List = new List<int>();

        //    teamA战斗结果.Win = isTeamAWin;
        //    teamA战斗结果.角色List = teamA战场.己方角色List;
        //    foreach (var 角色 in teamA战场.己方角色List)
        //    {
        //        if (角色.是否败退)
        //        {
        //            teamA战斗结果.回复兵力List.Add(0);
        //            continue;
        //        }
        //        else
        //        {
        //            int value = Convert.ToInt32(角色.最大兵力 * 常量.战斗后回复系数 / 100m);
        //            if (value + 角色.兵力 > 角色.最大兵力)
        //                value = 角色.最大兵力 - 角色.兵力;

        //            teamA战斗结果.回复兵力List.Add(value);
        //        }
        //    }


        //    foreach (var 角色 in teamA战场.己方角色List)
        //    {
        //        if (!角色.是否败退)
        //        {
        //            if (角色.被动技能 != null && 角色.被动技能 is 战斗结束被动技能)
        //            {
        //                战斗结束被动技能 战斗结束被动技能 = (战斗结束被动技能)角色.被动技能;
        //                战斗结束被动技能.Excute(teamA战斗结果, 角色);
        //            }

        //            if (角色.隐藏技能 != null && 角色.隐藏技能 is 战斗结束被动技能)
        //            {
        //                战斗结束被动技能 战斗结束被动技能 = (战斗结束被动技能)角色.被动技能;
        //                战斗结束被动技能.Excute(teamA战斗结果, 角色);
        //            }
        //        }
        //    }

        //    teamB战斗结果.Win = !isTeamAWin;
        //    teamB战斗结果.角色List = teamA战场.敌方角色List;
        //    foreach (var 角色 in teamA战场.敌方角色List)
        //    {
        //        if (角色.是否败退)
        //        {
        //            teamB战斗结果.回复兵力List.Add(0);
        //            continue;
        //        }
        //        else
        //        {
        //            int value = Convert.ToInt32(角色.最大兵力 * 常量.战斗后回复系数 / 100m);
        //            if (value + 角色.兵力 > 角色.最大兵力)
        //                value = 角色.最大兵力 - 角色.兵力;

        //            teamB战斗结果.回复兵力List.Add(value);
        //        }
        //    }

        //    foreach (var 角色 in teamA战场.敌方角色List)
        //    {
        //        if (!角色.是否败退)
        //        {
        //            if (角色.被动技能 != null && 角色.被动技能 is 战斗结束被动技能)
        //            {
        //                战斗结束被动技能 战斗结束被动技能 = (战斗结束被动技能)角色.被动技能;
        //                战斗结束被动技能.Excute(teamB战斗结果, 角色);
        //            }

        //            if (角色.隐藏技能 != null && 角色.隐藏技能 is 战斗结束被动技能)
        //            {
        //                战斗结束被动技能 战斗结束被动技能 = (战斗结束被动技能)角色.被动技能;
        //                战斗结束被动技能.Excute(teamB战斗结果, 角色);
        //            }
        //        }
        //    }

        //    for (int i = 0; i < teamA战场.己方角色List.Count; i++)
        //        teamA战场.己方角色List[i].兵力 += teamA战斗结果.回复兵力List[i];

        //    for (int i = 0; i < teamA战场.敌方角色List.Count; i++)
        //        teamA战场.敌方角色List[i].兵力 += teamB战斗结果.回复兵力List[i];

        //    return new List<战斗结果>() { teamA战斗结果, teamB战斗结果 };
        //}

        #endregion
    }
}
